home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / snippet.exe / STRAT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-01-05  |  3.9 KB  |  170 lines
  1. /*
  2. **  strat.c  10-5-91  Robert Mashlan, public domain
  3. **
  4. **   Interface functions to DOS 3.0+ set allocation strategy
  5. **   and get allocation strategy functions via int 21h,
  6. **   function 58h.
  7. **
  8. **   By setting the dos allocation strategy to LAST_FIT_LOW
  9. **   before using DOS the set handle count function int 21h,
  10. **   function 67h, DOS will allocate memory for the extended
  11. **   file handle table at the end of free memory instead of
  12. **   after the last heap allocation, with the benefit of
  13. **   allowing the heap manager make further contiguous
  14. **   allocations from the operating system.
  15. **
  16. */
  17.  
  18. #include "strat.h"
  19. #include <dos.h>
  20.  
  21. /*
  22. **   Gets dos memory allocation strategy via function 0x58.
  23. **   Returns  allocation strategy, else returns -1 and sets
  24. **   _doserrno on error.
  25. */
  26.  
  27. int get_alloc_strat(void)
  28. {
  29.       union REGS r;
  30.  
  31.       r.x.ax = 0x5800;              /* DOS "get allocation strategy" */
  32.       int86(0x21,&r,&r);
  33.       if (r.x.cflag)                /* error? */
  34.       {
  35.             _doserrno = r.x.ax;     /* save error code */
  36.             return -1;
  37.       }
  38.       else  return r.x.ax;
  39. }
  40.  
  41. /*
  42. **   Sets DOS memory allocation strategy
  43. **   returns allocation strategy on success,
  44. **   else returns -1 and sets _doserrno on error
  45. */
  46.  
  47. int set_alloc_strat( int strat )
  48. {
  49.       union REGS r;
  50.  
  51.       r.x.ax = 0x5801;              /* DOS "set allocation strategy" */
  52.       r.x.bx = strat;
  53.       int86(0x21,&r,&r);
  54.       if (r.x.cflag)                /* error? */
  55.       {
  56.             _doserrno = r.x.ax;     /* save error code */
  57.             return -1;
  58.       }
  59.       _doserrno = 0;
  60.       return strat;
  61. }
  62.  
  63. /*
  64. **   Uses dos function 67h to increase open file handle count.
  65. **   Returns -1 and sets _doserrno on error, 0 otherwise.
  66. */
  67.  
  68. int set_handle_count( unsigned nhandles )
  69. {
  70.       union REGS r;
  71.  
  72.       r.x.ax = 0x6700;
  73.       r.x.bx = nhandles;
  74.       int86(0x21,&r,&r);
  75.       if(r.x.cflag)
  76.       {
  77.             _doserrno = r.x.ax;
  78.             return -1;
  79.       }
  80.       _doserrno = 0;
  81.       return 0;
  82. }
  83.  
  84. #ifdef DEMO
  85.  
  86. #include <stdio.h>
  87. #include <stdlib.h>
  88. #include <io.h>
  89. #include <fcntl.h>
  90.  
  91. /*
  92. **  returns maximum number of files that can be open
  93. */
  94.  
  95. int handle_count(void)
  96. {
  97.       int handles[500];
  98.       int i, result;
  99.  
  100.       /* try allocating as many file handles as possible */
  101.  
  102.       for (i = 0; i < 500; i++)
  103.       {
  104.             if( (handles[i]=open("NUL",O_WRONLY)) == -1 )
  105.                   break;
  106.       }
  107.       result = i;
  108.  
  109.       /* close all files opened */
  110.  
  111.       for (i--; i >= 0; i--)
  112.             close(handles[i]);
  113.       return result;
  114. }
  115.  
  116.  
  117. /*
  118. **   Memory test, returns number of kilobytes that
  119. **   can be allocated before failure.
  120. */
  121.  
  122. int memtest(void)
  123. {
  124.       static void *mem[1024];
  125.       int i,result;
  126.  
  127.       /* try allocating as many 1K blocks as possible */
  128.  
  129.       for(i=0;i<1024;i++)
  130.       {
  131.             if( (mem[i]=malloc(1024)) == NULL )
  132.                   break;
  133.       }
  134.       result = i;                               /* save result */
  135.  
  136.       /* free memory allocated */
  137.  
  138.       for(i--; i >= 0; i--)
  139.             free(mem[i]);
  140.       return result;
  141. }
  142.  
  143. #define checkdoserror(f) \
  144.    ((f==-1)?printf("%s failed, doserror = %#02x\n",#f,_doserrno):(void)0)
  145.  
  146. int main(void)
  147. {
  148.       int strat;
  149.  
  150.       /* do pre-test diagnostics */
  151.  
  152.       printf("allocated %d Kbytes before failure\n",memtest());
  153.       printf("opened %d files\n",handle_count());
  154.  
  155.       strat = get_alloc_strat();  /* save current allocation strategy */
  156.       checkdoserror(set_alloc_strat(LAST_FIT_LOW));
  157.       puts("setting handle count to 50, with changed allocation strategy");
  158.       checkdoserror(set_handle_count(50));
  159.       checkdoserror(set_alloc_strat(strat)); /* restore strategy */
  160.  
  161.       /* do post-test diagnostics */
  162.  
  163.       printf("allocated %d Kbytes before failure\n",memtest());
  164.       printf("opened %d files\n",handle_count());
  165.  
  166.       return 0;
  167. }
  168.  
  169. #endif
  170.